home *** CD-ROM | disk | FTP | other *** search
/ The Fatted Calf / The Fatted Calf.iso / Applications / Misc / a2 / Source / makehgrtable.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-12  |  5.4 KB  |  208 lines
  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. static unsigned short one_to_two (int n);
  5. static unsigned short color_one_to_two (int n, int odd);
  6. static void printbin (unsigned short n);
  7.  
  8. int
  9. main()
  10. {
  11. #if 0
  12.   printbin (color_one_to_two (0x1, 1));
  13.   printbin (color_one_to_two (0x1400, 1));
  14.  
  15.  
  16. #else
  17.   int i, j, k;
  18.   static const unsigned short base[] = {
  19.     0x2000, 0x2080, 0x2100, 0x2180, 0x2200, 0x2280, 0x2300, 0x2380,
  20.     0x2028, 0x20A8, 0x2128, 0x21A8, 0x2228, 0x22A8, 0x2328, 0x23A8,
  21.     0x2050, 0x20D0, 0x2150, 0x21D0, 0x2250, 0x22D0, 0x2350, 0x23D0 };
  22.   unsigned char row[0x2000];
  23.  
  24.   memset (row, 0, 0x2000);
  25.   for (i = 0; i < 24; i++)
  26.     for (j = 0; j < 8; j++)
  27.       for (k = 0; k < 40; k++)
  28.     row[base[i] - 0x2000 + 0x400 * j + k] = i * 8 + j;
  29.  
  30.  
  31.   /* Output addr_to_row. */
  32.  
  33.   puts ("/* addr_to_row[(addr & 0x1FFF) / 8] contains  */\n"
  34.     "/* the screen row for a given hires address. */\n");
  35.  
  36.   fputs ("const unsigned char addr_to_row[] = {\n   ", stdout);
  37.   for (i = 0; i < 0x2000; i += 8)
  38.     {
  39.       if (i && !(i % 64))
  40.     printf ("       /* 0x%04X - 0x%04X */\n   ",
  41.         i + 0x2000 - 64, i + 0x2000 - 1);
  42.       printf ("%3d%s ", row[i], i == 0x2000 -8 ? "" : ",");
  43.     }
  44.   printf ("        /* 0x3FC0 - 0x3FFF */\n};\n", i + 0x2000 - 64);
  45.  
  46.  
  47.   /* Output row_to_addr. */
  48.  
  49.   puts ("\n\n"
  50.     "/* row_to_addr[row] contains the base address for a given row. */\n");
  51.   fputs ("const unsigned int row_to_addr[] = {", stdout);
  52.   for (i = 0; i < 24; i++)
  53.     {
  54.       fputs ("\n   ", stdout);
  55.       for (j = 0; j < 8; j++)
  56.     printf ("0x%04X%s ", base[i] + 0x400 * j - 0x2000,
  57.         (i == 23 && j == 7) ? "" : ",");
  58.     }
  59.   puts ("\n};");
  60.  
  61.   puts ("\n\n"
  62.     "#if !USE_COLOR\n"
  63.     "/* one_to_two_bpp[byte] maps one bit per pixel to two for the */\n"
  64.     "/* low 7 bits, reversing the order.                           */\n");
  65.   fputs ("const unsigned long one_to_two_bpp[] = {", stdout);
  66.   
  67.   for (i = 0; i < 32; i++)
  68.     {
  69.       fputs ("\n   ", stdout);
  70.       for (j = 0; j < 8; j++)
  71.     printf ("0x%04X%s ",
  72.         (unsigned long) (one_to_two (i * 8 + j)),
  73.         (i == 31 && j == 7) ? "" : ",");
  74.     }
  75.   puts ("\n};");
  76.  
  77.   puts ("\n#else\n"
  78.     "/* color_one_to_two_bpp[13 bits] is like one_to_two_bpp, except */\n"
  79.     "/* that it maps a set of pixels to a 2-bit color version of     */\n"
  80.     "/* those pixels.  The 13 pixels are the five to the left of a   */\n"
  81.     "/* given screen byte and the screen byte itself.  The output    */\n"
  82.     "/* represents the rightmost two pixels of the byte to the left  */\n"
  83.     "/* and the leftmost 5 pixels of the current byte.               */\n"
  84.     "/* Note that not all pixels are converted; two on each edge are */\n"
  85.     "/* only there to  convey information about how to color the     */\n"
  86.     "/* interior pixels.  The color bit of the byte is ignored.      */\n"
  87.     );
  88.  
  89.   fputs ("const unsigned short color_one_to_two_bpp_even[] = {",stdout);
  90.   for (i = 0; i < 16384 / 8; i++)
  91.     {
  92.       fputs ("\n   ", stdout);
  93.       for (j = 0; j < 8; j++)
  94.     printf ("0x%04X%s ",
  95.         (unsigned long) (color_one_to_two (i * 8 + j, 0)),
  96.         (i == 16384 / 8 - 1 && j == 7) ? "" : ",");
  97.     }
  98.   puts ("\n};\n");
  99.  
  100.   fputs ("const unsigned short color_one_to_two_bpp_odd[] = {", stdout);
  101.   for (i = 0; i < 16384 / 8; i++)
  102.     {
  103.       fputs ("\n   ", stdout);
  104.       for (j = 0; j < 8; j++)
  105.     printf ("0x%04X%s ",
  106.         (unsigned long) (color_one_to_two (i * 8 + j, 1)),
  107.         (i == 16384 / 8 - 1 && j == 7) ? "" : ",");
  108.     }
  109.   puts ("\n};\n#endif");
  110.  
  111. #endif
  112.  
  113.   return 0;
  114. }
  115.  
  116.  
  117. static unsigned short
  118. one_to_two (int n)
  119. {
  120.   unsigned short res = 0;
  121.   int mask;
  122.  
  123.   for (mask = 1; mask != 128; res <<= 2, mask <<= 1)
  124.     if (n & mask)
  125.       res |= 3;
  126.   return res >> 2;
  127. }
  128.  
  129. static unsigned short
  130. color_one_to_two (int n, int odd)
  131. {
  132.   int bitnum;
  133.   int i, new;
  134.   static const int bitmask[] = {
  135.     1 << 8, 1 << 9, 1 << 10, 1 << 11, 1 << 12, 1 << 13, 1, 2, 4, 8, 16, 32, 64
  136.     };
  137.   unsigned short res;
  138.  
  139. /* For each bit:
  140.    1) All pixels start out black.
  141.    For each bit:
  142.    2) If bit is on, see if either neighbor is on.
  143.      a) If either is on, make this bit white.
  144.      b) If neither is on, see if any neighbors 2-away are on.  If either is on,
  145.        i) If our bitnumber + odd is an odd number, we are light gray.
  146.        ii) Else, we are dark gray.
  147.      c) If we are gray, make both neighbors be our color.  
  148.    3) If this bit is off, go on to the next one.
  149. */
  150.  
  151.   /* Convert it to "canonical form" here (punt unused bit, reorder so
  152.    * leftmost pixels are high bits, etc.)
  153.    */
  154.  
  155.   new = 0;
  156.   for (i = 0; i < 13; i++)
  157.     if (n & bitmask[i])
  158.       new |= (1 << (12 - i));
  159.   n = new;
  160.  
  161. /*
  162.   printf ("Converting: "); printbin (n);
  163. */
  164.  
  165.   /* At this point we have 13 bits; 3 on the left and 3 on the right for
  166.    * information, and 7 to generate pixels for.
  167.    */
  168.  
  169.   res = 0;  /* Default to black. */
  170. #define BIT(b) ((n & (1 << ((b) + 2))) != 0)
  171.  
  172.   /* Convert 9 bits instead of 7 so color outside the bits in question
  173.    * can bleed back in.
  174.    */
  175.  
  176.  
  177.   for (bitnum = 0; bitnum < 9; bitnum++)
  178.     {
  179.       if (BIT (bitnum))
  180.     {
  181.       if (BIT (bitnum + 1) || BIT (bitnum - 1)
  182.           || !(BIT (bitnum + 2) || BIT (bitnum - 2)))
  183.         {
  184.           res |= 3 << (bitnum * 2);
  185.         }
  186.       else
  187.         {
  188.           /* Go ahead, just TRY to figure this out.  :-) */
  189.           res |= (((1L | 4 | 16) << ((bitnum * 2) + !((bitnum + odd) & 1)))
  190.               >> 2);
  191.         }
  192.     }
  193.     }
  194.  
  195.   return ((res >> 2) & 0x3FFF);   /* Only 14 bits. */
  196. }
  197.  
  198.  
  199. static void
  200. printbin (unsigned short n)
  201. {
  202.   unsigned short mask;
  203.  
  204.   for (mask = 0x8000; mask != 0; mask >>= 1)
  205.     putchar ('0' + !!(n & mask));
  206.   putchar ('\n');
  207. }
  208.